// Compact frametime statistics bucket.
//
// Stores average and maximum frametime values using 16-bit integers
// with fixed-point quantization.
//
// ------------------------------------------------------------------
// Encoding
// ------------------------------------------------------------------
//
// Values are stored in units of 16 microseconds:
//
//     stored_value = frametime_us / 16
//
// This allows a uint16_t to represent:
//
//     65535 * 16 us = 1,048,560 us
//                   = ~1048 ms
//
// which comfortably covers extremely slow frames (~1 FPS).
//
// ------------------------------------------------------------------
// Precision
// ------------------------------------------------------------------
//
// Quantization step:
//
//     16 us = 0.016 ms
//
// Maximum quantization error:
//
//     +/- 8 us
//
// This is effectively negligible for FPS telemetry.
//
// Example:
//
//     16.667 ms frame (60 FPS)
//
// Encoded as:
//
//     16667 us / 16 = 1042
//
// Decoded:
//
//     1042 * 16 = 16672 us
//
// Error:
//
//     +5 us = 0.005 ms
//
// ------------------------------------------------------------------
// Why fixed-point quantization?
// ------------------------------------------------------------------
//
// Advantages:
//
// - extremely compact (4 bytes total per bucket)
// - deterministic runtime cost
// - cache friendly
// - no floating-point storage
// - sufficient precision for telemetry
// - supports >1 second frametimes
//
// ------------------------------------------------------------------
// Intended usage
// ------------------------------------------------------------------
//
// Typical bucket generation:
//
//     avgFrameUs = accumulatedFrameUs / frameCount
//     maxFrameUs = worstFrameUsSeen
//
// Then:
//
//     bucket.SetAvgUs(avgFrameUs);
//     bucket.SetMaxUs(maxFrameUs);
//
// ------------------------------------------------------------------
// Recommended usage pattern
// ------------------------------------------------------------------
//
// Build buckets over fixed time windows:
//
//     e.g. 50 ms or 100 ms
//
// rather than fixed frame counts.
//
// This keeps statistical resolution stable across varying FPS.
//
// ------------------------------------------------------------------

struct FrameBucket
{
    uint16_t avg16us;
    uint16_t max16us;

    static constexpr uint32_t QUANTUM_US    = 16;
    static constexpr uint32_t QUANTUM_SHIFT = 4;

    static constexpr uint32_t MAX_US =
        0xFFFFu * QUANTUM_US;

    // Encode microseconds into 16 us fixed-point units.
    //
    // Rounds to nearest unit.
    //
    // Input is clamped to representable range.
    static uint16_t EncodeUs(uint32_t us)
    {
        if (us > MAX_US)
            us = MAX_US;

        return static_cast<uint16_t>(
            (us + (QUANTUM_US / 2)) >> QUANTUM_SHIFT);
    }

    // Decode fixed-point units back into microseconds.
    static uint32_t DecodeUs(uint16_t v)
    {
        return static_cast<uint32_t>(v)
            << QUANTUM_SHIFT;
    }

    void SetAvgUs(uint32_t us)
    {
        avg16us = EncodeUs(us);
    }

    void SetMaxUs(uint32_t us)
    {
        max16us = EncodeUs(us);
    }

    uint32_t GetAvgUs() const
    {
        return DecodeUs(avg16us);
    }

    uint32_t GetMaxUs() const
    {
        return DecodeUs(max16us);
    }

    float GetAvgMs() const
    {
        return static_cast<float>(GetAvgUs()) * 0.001f;
    }

    float GetMaxMs() const
    {
        return static_cast<float>(GetMaxUs()) * 0.001f;
    }

    float GetAvgFPS() const
    {
        const uint32_t us = GetAvgUs();

        return (us > 0)
            ? (1000000.0f / static_cast<float>(us))
            : 0.0f;
    }

    float GetMinFPS() const
    {
        const uint32_t us = GetMaxUs();

        return (us > 0)
            ? (1000000.0f / static_cast<float>(us))
            : 0.0f;
    }
};

// ============================================================================
// Rolling 3-second FPS statistics
// ============================================================================
//
// Stores:
//
//     3 seconds @ 10 ms resolution
//
// = 300 buckets
//
// Each bucket summarizes:
//
//     - average frametime
//     - worst frametime
//
// over a 10 ms interval.
//
// ============================================================================

class FpsHistory
{
public:

    static constexpr uint32_t BUCKET_INTERVAL_US = 10000; // 10 ms
    static constexpr uint32_t HISTORY_SECONDS    = 3;

    static constexpr uint32_t BUCKET_COUNT =
        (HISTORY_SECONDS * 1000000) / BUCKET_INTERVAL_US;

    // ------------------------------------------------------------------------

    void Reset()
    {
        m_writeIndex = 0;
        m_bucketCount = 0;

        m_accumulatedUs = 0;
        m_accumulatedFrames = 0;
        m_maxFrameUs = 0;
        m_bucketElapsedUs = 0;

        std::fill(
            std::begin(m_buckets),
            std::end(m_buckets),
            FrameBucket{});
    }

    // ------------------------------------------------------------------------
    // Add a frame
    //
    // frameUs:
    //     frametime in microseconds
    //
    // Example:
    //
    //     16.667 ms = 16667 us
    //
    // ------------------------------------------------------------------------

    void AddFrame(uint32_t frameUs)
    {
        // Accumulate stats for current bucket.

        m_accumulatedUs += frameUs;
        m_accumulatedFrames++;

        if (frameUs > m_maxFrameUs)
            m_maxFrameUs = frameUs;

        m_bucketElapsedUs += frameUs;

        // Emit one or more buckets if enough time elapsed.

        while (m_bucketElapsedUs >= BUCKET_INTERVAL_US)
        {
            EmitBucket();

            m_bucketElapsedUs -= BUCKET_INTERVAL_US;
        }
    }

    // ------------------------------------------------------------------------

    float GetAverageFPS() const
    {
        if (m_bucketCount == 0)
            return 0.0f;

        uint64_t totalUs = 0;

        for (uint32_t i = 0; i < m_bucketCount; ++i)
        {
            totalUs += m_buckets[i].GetAvgUs();
        }

        const float avgUs =
            static_cast<float>(totalUs)
            / static_cast<float>(m_bucketCount);

        return avgUs > 0.0f
            ? (1000000.0f / avgUs)
            : 0.0f;
    }

    // ------------------------------------------------------------------------
    // Approximate 1% low FPS
    //
    // Uses the worst bucket frametimes.
    //
    // This is intentionally approximate and designed for:
    //
    // - low memory use
    // - deterministic runtime
    // - good stutter detection
    //
    // ------------------------------------------------------------------------

    float GetOnePercentLowFPS() const
    {
        if (m_bucketCount == 0)
            return 0.0f;

        uint32_t worstUs = 0;

        // Find worst bucket maximum frametime.

        for (uint32_t i = 0; i < m_bucketCount; ++i)
        {
            worstUs = std::max(
                worstUs,
                m_buckets[i].GetMaxUs());
        }

        return worstUs > 0
            ? (1000000.0f / static_cast<float>(worstUs))
            : 0.0f;
    }

private:

    // ------------------------------------------------------------------------

    void EmitBucket()
    {
        FrameBucket& bucket =
            m_buckets[m_writeIndex];

        // Compute average frametime for bucket.

        const uint32_t avgUs =
            (m_accumulatedFrames > 0)
            ? static_cast<uint32_t>(
                m_accumulatedUs / m_accumulatedFrames)
            : 0;

        bucket.SetAvgUs(avgUs);
        bucket.SetMaxUs(m_maxFrameUs);

        // Advance ring buffer.

        m_writeIndex =
            (m_writeIndex + 1) % BUCKET_COUNT;

        if (m_bucketCount < BUCKET_COUNT)
            ++m_bucketCount;

        // Reset accumulators.

        m_accumulatedUs = 0;
        m_accumulatedFrames = 0;
        m_maxFrameUs = 0;
    }

private:

    FrameBucket m_buckets[BUCKET_COUNT];

    uint32_t m_writeIndex = 0;
    uint32_t m_bucketCount = 0;

    uint64_t m_accumulatedUs = 0;
    uint32_t m_accumulatedFrames = 0;
    uint32_t m_maxFrameUs = 0;

    uint32_t m_bucketElapsedUs = 0;
};

// ============================================================================
// Example usage
// ============================================================================

int main()
{
    FpsHistory history;

    history.Reset();

    // Simulate ~60 FPS.

    for (int i = 0; i < 500; ++i)
    {
        uint32_t frameUs = 16667;

        // Simulate occasional stutter.

        if ((i % 120) == 0)
        {
            frameUs = 50000; // 50 ms hitch
        }

        history.AddFrame(frameUs);
    }

    printf(
        "Average FPS: %.2f\n",
        history.GetAverageFPS());

    printf(
        "Approx 1%% Low FPS: %.2f\n",
        history.GetOnePercentLowFPS());

    return 0;
}

// Compact frametime statistics bucket.
//
// Stores average and maximum frametime values using 16-bit integers
// with fixed-point quantization.
//
// ------------------------------------------------------------------
// Encoding
// ------------------------------------------------------------------
//
// Values are stored in units of 16 microseconds:
//
//     stored_value = frametime_us / 16
//
// This allows a uint16_t to represent:
//
//     65535 * 16 us = 1,048,560 us
//                   = ~1048 ms
//
// which comfortably covers extremely slow frames (~1 FPS).
//
// ------------------------------------------------------------------
// Precision
// ------------------------------------------------------------------
//
// Quantization step:
//
//     16 us = 0.016 ms
//
// Maximum quantization error:
//
//     +/- 8 us
//
// This is effectively negligible for FPS telemetry.
//
// Example:
//
//     16.667 ms frame (60 FPS)
//
// Encoded as:
//
//     16667 us / 16 = 1042
//
// Decoded:
//
//     1042 * 16 = 16672 us
//
// Error:
//
//     +5 us = 0.005 ms
//
// ------------------------------------------------------------------
// Why fixed-point quantization?
// ------------------------------------------------------------------
//
// Advantages:
//
// - extremely compact (4 bytes total per bucket)
// - deterministic runtime cost
// - cache friendly
// - no floating-point storage
// - sufficient precision for telemetry
// - supports >1 second frametimes
//
// ------------------------------------------------------------------
// Intended usage
// ------------------------------------------------------------------
//
// Typical bucket generation:
//
//     avgFrameUs = accumulatedFrameUs / frameCount
//     maxFrameUs = worstFrameUsSeen
//
// Then:
//
//     bucket.SetAvgUs(avgFrameUs);
//     bucket.SetMaxUs(maxFrameUs);
//
// ------------------------------------------------------------------
// Recommended usage pattern
// ------------------------------------------------------------------
//
// Build buckets over fixed time windows:
//
//     e.g. 50 ms or 100 ms
//
// rather than fixed frame counts.
//
// This keeps statistical resolution stable across varying FPS.
//
// ------------------------------------------------------------------

struct FrameBucket
{
    uint16_t avg16us;
    uint16_t max16us;

    static constexpr uint32_t QUANTUM_US    = 16;
    static constexpr uint32_t QUANTUM_SHIFT = 4;

    static constexpr uint32_t MAX_US =
        0xFFFFu * QUANTUM_US;

    // Encode microseconds into 16 us fixed-point units.
    //
    // Rounds to nearest unit.
    //
    // Input is clamped to representable range.
    static uint16_t EncodeUs(uint32_t us)
    {
        if (us > MAX_US)
            us = MAX_US;

        return static_cast<uint16_t>(
            (us + (QUANTUM_US / 2)) >> QUANTUM_SHIFT);
    }

    // Decode fixed-point units back into microseconds.
    static uint32_t DecodeUs(uint16_t v)
    {
        return static_cast<uint32_t>(v)
            << QUANTUM_SHIFT;
    }

    void SetAvgUs(uint32_t us)
    {
        avg16us = EncodeUs(us);
    }

    void SetMaxUs(uint32_t us)
    {
        max16us = EncodeUs(us);
    }

    uint32_t GetAvgUs() const
    {
        return DecodeUs(avg16us);
    }

    uint32_t GetMaxUs() const
    {
        return DecodeUs(max16us);
    }

    float GetAvgMs() const
    {
        return static_cast<float>(GetAvgUs()) * 0.001f;
    }

    float GetMaxMs() const
    {
        return static_cast<float>(GetMaxUs()) * 0.001f;
    }

    float GetAvgFPS() const
    {
        const uint32_t us = GetAvgUs();

        return (us > 0)
            ? (1000000.0f / static_cast<float>(us))
            : 0.0f;
    }

    float GetMinFPS() const
    {
        const uint32_t us = GetMaxUs();

        return (us > 0)
            ? (1000000.0f / static_cast<float>(us))
            : 0.0f;
    }
};

// ============================================================================
// Rolling 3-second FPS statistics
// ============================================================================
//
// Stores:
//
//     3 seconds @ 10 ms resolution
//
// = 300 buckets
//
// Each bucket summarizes:
//
//     - average frametime
//     - worst frametime
//
// over a 10 ms interval.
//
// ============================================================================

class FpsHistory
{
public:

    static constexpr uint32_t BUCKET_INTERVAL_US = 10000; // 10 ms
    static constexpr uint32_t HISTORY_SECONDS    = 3;

    static constexpr uint32_t BUCKET_COUNT =
        (HISTORY_SECONDS * 1000000) / BUCKET_INTERVAL_US;

    // ------------------------------------------------------------------------

    void Reset()
    {
        m_writeIndex = 0;
        m_bucketCount = 0;

        m_accumulatedUs = 0;
        m_accumulatedFrames = 0;
        m_maxFrameUs = 0;
        m_bucketElapsedUs = 0;

        std::fill(
            std::begin(m_buckets),
            std::end(m_buckets),
            FrameBucket{});
    }

    // ------------------------------------------------------------------------
    // Add a frame
    //
    // frameUs:
    //     frametime in microseconds
    //
    // Example:
    //
    //     16.667 ms = 16667 us
    //
    // ------------------------------------------------------------------------

    void AddFrame(uint32_t frameUs)
    {
        // Accumulate stats for current bucket.

        m_accumulatedUs += frameUs;
        m_accumulatedFrames++;

        if (frameUs > m_maxFrameUs)
            m_maxFrameUs = frameUs;

        m_bucketElapsedUs += frameUs;

        // Emit one or more buckets if enough time elapsed.

        while (m_bucketElapsedUs >= BUCKET_INTERVAL_US)
        {
            EmitBucket();

            m_bucketElapsedUs -= BUCKET_INTERVAL_US;
        }
    }

    // ------------------------------------------------------------------------

    float GetAverageFPS() const
    {
        if (m_bucketCount == 0)
            return 0.0f;

        uint64_t totalUs = 0;

        for (uint32_t i = 0; i < m_bucketCount; ++i)
        {
            totalUs += m_buckets[i].GetAvgUs();
        }

        const float avgUs =
            static_cast<float>(totalUs)
            / static_cast<float>(m_bucketCount);

        return avgUs > 0.0f
            ? (1000000.0f / avgUs)
            : 0.0f;
    }

    // ------------------------------------------------------------------------
    // Approximate 1% low FPS
    //
    // Uses the worst bucket frametimes.
    //
    // This is intentionally approximate and designed for:
    //
    // - low memory use
    // - deterministic runtime
    // - good stutter detection
    //
    // ------------------------------------------------------------------------

    float GetOnePercentLowFPS() const
    {
        if (m_bucketCount == 0)
            return 0.0f;

        uint32_t worstUs = 0;

        // Find worst bucket maximum frametime.

        for (uint32_t i = 0; i < m_bucketCount; ++i)
        {
            worstUs = std::max(
                worstUs,
                m_buckets[i].GetMaxUs());
        }

        return worstUs > 0
            ? (1000000.0f / static_cast<float>(worstUs))
            : 0.0f;
    }

private:

    // ------------------------------------------------------------------------

    void EmitBucket()
    {
        FrameBucket& bucket =
            m_buckets[m_writeIndex];

        // Compute average frametime for bucket.

        const uint32_t avgUs =
            (m_accumulatedFrames > 0)
            ? static_cast<uint32_t>(
                m_accumulatedUs / m_accumulatedFrames)
            : 0;

        bucket.SetAvgUs(avgUs);
        bucket.SetMaxUs(m_maxFrameUs);

        // Advance ring buffer.

        m_writeIndex =
            (m_writeIndex + 1) % BUCKET_COUNT;

        if (m_bucketCount < BUCKET_COUNT)
            ++m_bucketCount;

        // Reset accumulators.

        m_accumulatedUs = 0;
        m_accumulatedFrames = 0;
        m_maxFrameUs = 0;
    }

private:

    FrameBucket m_buckets[BUCKET_COUNT];

    uint32_t m_writeIndex = 0;
    uint32_t m_bucketCount = 0;

    uint64_t m_accumulatedUs = 0;
    uint32_t m_accumulatedFrames = 0;
    uint32_t m_maxFrameUs = 0;

    uint32_t m_bucketElapsedUs = 0;
};

// ============================================================================
// Example usage
// ============================================================================

int main()
{
    FpsHistory history;

    history.Reset();

    // Simulate ~60 FPS.

    for (int i = 0; i < 500; ++i)
    {
        uint32_t frameUs = 16667;

        // Simulate occasional stutter.

        if ((i % 120) == 0)
        {
            frameUs = 50000; // 50 ms hitch
        }

        history.AddFrame(frameUs);
    }

    printf(
        "Average FPS: %.2f\n",
        history.GetAverageFPS());

    printf(
        "Approx 1%% Low FPS: %.2f\n",
        history.GetOnePercentLowFPS());

    return 0;
}

#include <array>
#include <cstdint>
#include <random>

static void FloatArrayAccumulate(benchmark::State& state) {
  std::array<float, 4096> values;

  std::mt19937 rng(12345);
  std::uniform_real_distribution<float> dist(0.0f, 1.0f);

  // Fill array with random floats
  for (float& v : values) {
    v = dist(rng);
  }

  for (auto _ : state) {
    // Accumulate values
    float sum = 0.0f;
    for (float v : values) {
      sum += v;
    }

    benchmark::DoNotOptimize(sum);
  }
}
BENCHMARK(FloatArrayAccumulate);

static void UShortArrayAccumulateMul16(benchmark::State& state) {
  std::array<unsigned short, 4096> values;

  std::mt19937 rng(12345);
  std::uniform_int_distribution<unsigned short> dist(0, 65535);

  // Fill array with random unsigned shorts
  for (unsigned short& v : values) {
    v = dist(rng);
  }

  static constexpr uint32_t QUANTUM_SHIFT = 4; // represents 16 microseconds

  for (auto _ : state) {
    // Accumulate values shifted by 4
    uint64_t sum = 0;
    for (unsigned short v : values) {
      sum += static_cast<uint64_t>(v) << QUANTUM_SHIFT;
    }

    benchmark::DoNotOptimize(sum);
  }
}
BENCHMARK(UShortArrayAccumulateMul16);